백그라운드 실행과 쓰레드

flowchart LR
    BG["🔄 백그라운드 실행"]
    T["쓰레드\n(Thread)"]
    P["프로세스\n(Process)"]
    OS["OS 스케줄링\n(Time Slicing)"]
 
    BG --> T
    BG --> P
    BG --> OS
 
    T --- T_DESC["한 프로세스 안에서\n메모리 공유하며 분리"]
    P --- P_DESC["완전히 별도 프로그램\nIPC로 통신"]
    OS --- OS_DESC["CPU 시간을 나눠\n번갈아 실행"]

flowchart TB
    subgraph Process["내 노드 프로세스"]
        direction TB
        Main["메인 쓰레드\n제어 루프: 목표 계산 → IK → 발행"]
        Callback["콜백 쓰레드\n/joint_states 수신 → 변수 갱신"]
        Shared[("공유 메모리\nself._current_joints")]
    end
 
    Main <--> Shared
    Callback <--> Shared

import threading
 
shared_data = {"joints": [0.0, 0.0, 0.0]}
lock = threading.Lock()
 
def callback_thread():
    """콜백 쓰레드: 센서 데이터를 갱신"""
    while True:
        new_data = receive_joint_states()  # 데이터 수신
        with lock:  # 동기화: 동시 접근 방지
            shared_data["joints"] = new_data
 
def main_thread():
    """메인 쓰레드: 제어 루프 실행"""
    while True:
        with lock:
            current = shared_data["joints"]  # 공유 데이터 읽기
        command = compute_control(current)
        publish(command)

flowchart LR
    subgraph System["시스템"]
        A["ros2_control\n프로세스"]
        B["robot_state_publisher\n프로세스"]
        C["move_group\n프로세스"]
        D["내 노드\n프로세스"]
    end
 
    A -- "/joint_states\n(토픽)" --> D
    B -- "/tf\n(토픽)" --> C
    C -- "/compute_ik\n(서비스)" --> D

# ROS2에서 각각 별도 프로세스로 실행
ros2 run ros2_control_node ros2_control_node &   # 프로세스 1
ros2 run robot_state_publisher robot_state_publisher &  # 프로세스 2
ros2 run moveit2 move_group &                     # 프로세스 3
ros2 run my_pkg my_node &                         # 프로세스 4

sequenceDiagram
    participant Node as 내 노드
    participant OS as 운영체제
    participant Other as 다른 프로세스/쓰레드
 
    Node->>OS: sleep(33ms) 호출
    OS->>Other: CPU 할당 (다른 작업 처리)
    Note over Other: 33ms 동안 실행
    OS->>Node: 33ms 경과 → CPU 재할당
    Node->>Node: 제어 루프 계속 실행

from rclpy.executors import SingleThreadedExecutor
 
executor = SingleThreadedExecutor()
executor.add_node(my_node)
executor.spin()
# → 콜백을 순서대로 하나씩 처리. 쓰레드 추가 생성 없음.

sequenceDiagram
    participant E as Executor (쓰레드 1개)
 
    E->>E: 제어 루프 실행
    E->>E: sleep(33ms)
    E->>E: /joint_states 콜백 처리
    E->>E: 제어 루프 재개
    Note over E: 하나의 쓰레드에서 순차 실행

from rclpy.executors import MultiThreadedExecutor
 
executor = MultiThreadedExecutor(num_threads=4)
executor.add_node(my_node)
executor.spin()
# → 콜백을 여러 쓰레드에서 동시 처리

sequenceDiagram
    participant T1 as 쓰레드 1
    participant T2 as 쓰레드 2
    participant T3 as 쓰레드 3
 
    par 병렬 실행
        T1->>T1: 제어 루프 실행
    and
        T2->>T2: /joint_states 콜백
    and
        T3->>T3: /tf 콜백
    end
    Note over T1,T3: 진짜 동시 실행 (멀티코어 활용)

flowchart TD
    Q1{"콜백 처리 시간이\n제어 주기보다 긴가?"}
    Q2{"공유 데이터에\n동시 접근이 있는가?"}
 
    Single["SingleThreadedExecutor\n간단하고 안전"]
    Multi["MultiThreadedExecutor\n+ Lock 동기화"]
    SingleOK["SingleThreadedExecutor\n충분히 빠름"]
 
    Q1 -- "아니오" --> SingleOK
    Q1 -- "예" --> Q2
    Q2 -- "예" --> Multi
    Q2 -- "아니오" --> Multi